
import java.io.File;
import java.util.Iterator;
import java.util.List;
import org.jdom.*;
import org.jdom.input.*;
import java.util.ArrayList;
/**
* Questa classe apre il file impostazioni.xml, ne verifica la correttezza, intesa come 
* presenza di tutti i campi obbligatori, e restituisce il valore dei campi necessari a
* all'avvio di una parita
* 
* La classe mette a disposizione quattro metodi utilizzabili rispettivamente per creare
* un oggetto Document per accedere al file .xml, recuperare le frasi con i rispettivi
* suggerimenti, recuperare i nomi dei giocatori e gli elementi della ruota con le 
* relative probabilità di uscita.
*
* Il primo metodo ad essere richiamato deve essere obbligatoriamente readFile() altriemnti
*  i restanti tre metodi non risultano utilizzabili, ovviamente è implementato il 
* controllo necessario alla non infrazione di questa regola.
* 
* @autor Matteo Francia
* @author Carlo Donzelli
*/
public class XMLReader 
{ 
  Document document;
  /**
  * Questo metodo si incarica di creare l'oggetto document tramite il quale
  * diventi possibile accedere ai dati contenuti in impostazioni.xml gestendo 
  * le eventuali eccezioni generate durante il processo.
  * 
  * @autor Matteo Francia
  */
  private void readFile()
  {
    try 
    {
       // Crea un SAXBuilder e lo uso per costruire un document
      SAXBuilder builder = new SAXBuilder();
      // Crea un oggetto document sul file XML costruito dal builder 
      // a sua volta su un oggetto File generico
      File file=new File("impostazioni.xml");
     
      // viene resa possibile l'utilizzazione dei metodi pubblici della classe
      // CMLReader solo dopo aver verificato la correttezza del file
      if(isCorrect())
      {
        document = builder.build(file);
      }
    }
    catch (java.io.IOException e1) 
    {
        System.out.println("Errore del SAXBuilder!");
    }
    catch (NullPointerException e2) 
    {
        System.out.println("Attenzione! \n Impossibile localizzare il file impostazioni.xml");
    }
    catch (org.jdom.JDOMException e3) 
    {
        System.out.println("Errore di Document!");
    }  
  }
  
  /**
   *  public static void main(String[] args) 
  {
    XMLReader lettore=new XMLReader();
    lettore.readFile();            
   
    
  }   */
  
  
  /**
   * 
   * @return
   */
  private boolean isCorrect()
   {
      return true;
   }
  
  /**
   * Questo metodo restituisce un ArrayList di stringhe rappresentanti le frasi,
   * negli indici pari, e i relativi suggerimenti negli indici dispari.
   * 
   * @return L'arraylist contenente le frasi da indovinare ed i relativi suggerimenti
   * @autor Matteo Francia
   */
  public ArrayList<String> getPhrases()
  {
    ArrayList<String> phrases=new ArrayList<String>();
    readFile();
    
    //Prendo la radice <game>
    Element root =document.getRootElement();
    //Estraggo i figli del primo figlio della radice(cioè i figli di<phrases>) della radice
    List children = root.getChild("phrases").getChildren();
    Iterator iterator = children.iterator();
    
    //estraggo uno ad uno gli elementi <phrase> inserendo i valori dei campi
    //<text> e <hint> nell'arraylist.
    while(iterator.hasNext())
    {
        Element item = (Element)iterator.next(); 
        Element text = item.getChild("text");
        phrases.add(text.getText().trim());
        Element hint = item.getChild("hint");
        phrases.add(hint.getText().trim());
    }
    
    return phrases;
  }
  
  /**
   * Questo metodo recupera dal file impostazioni.xml i nomi dei partecipanti ad una partita
   * 
   * @return players,l'arraylist contenente l'elenco dei nomi dei partecipanti
   * @autor Matteo Francia
   */
  public ArrayList<String> getPlayers()
  {
    ArrayList<String> players=new ArrayList<String>();
    readFile();
    
    //Prendo la radice <game>
    Element root =document.getRootElement();
    //Estraggo i figli del primo figlio della radice(cioè i figli di<phrases>) della radice
    List children = root.getChild("players").getChildren();
    Iterator iterator = children.iterator();
    
    //estraggo uno ad uno gli elementi <phrase> inserendo i valori dei campi
    //<text> e <hint> nell'arraylist.
    while(iterator.hasNext())
    {
        Element item = (Element)iterator.next(); 
        Element name = item.getChild("name");
        players.add(name.getText().trim());
        System.out.println(name.getText().trim());
    }
    
    return players;
  }
  
  /**
   * Questo metodo analizza il file impostazioni.xml al fine di estrarre le informazioni necessarie
   * alla creazione di una ruota per il gioco.
   * 
   * @return Restituisce l'arraylist contenente gli elementi della ruota con le relative probabilita'
   * @autor Matteo Francia
   */
  public ArrayList<String> getWheelElements()
  {
     ArrayList<String> wheelElements=new ArrayList<String>();
     readFile();
    
    //Prendo la radice <game>
    Element root =document.getRootElement();
    //Estraggo i figli del primo figlio della radice(cioè i figli di<phrases>) della radice
    List children = root.getChild("wheel").getChild("elements").getChildren();
    Iterator iterator = children.iterator();
    //System.out.println("wheel ha "+children.size()+" figli");
    
    //estraggo uno ad uno gli elementi <phrase> inserendo i valori dei campi
    //<text> e <hint> nell'arraylist.
    while(iterator.hasNext())
    {
        Element item = (Element)iterator.next(); 
        Element value = item.getChild("value");
        wheelElements.add(value.getText().trim());
        Element probability = item.getChild("probability");
        wheelElements.add(probability.getText().trim());
    }
        
    return wheelElements;
  }
  
   /*public static void main(String[] args) 
  {
    XMLReader lettore=new XMLReader();
    lettore.readFile();
    lettore.getPhrases();
    lettore.getWheelElements();
    lettore.getPlayers();
   
    
  }*/
}